Aller au contenu principal

Fichier texte

Lecture (BufferedReader + FileReader)​

  • Lecture simple d’un fichier texte ligne par ligne. FileReader ouvre le fichier et BufferedReader accélère la lecture et donne accès à readLine().

  • FileReader ouvre un fichier texte en lecture.

  • BufferedReader ajoute un tampon et fournit readLine().

  • Lecture ligne par ligne, simple et efficace.

Exemple lecture​

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LectureFichierSimple {

    public static void main(String[] args) {
        StringBuilder contenu = new StringBuilder();

        try (FileReader fileReader = new FileReader("abc.txt");
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            String ligne;
            while ((ligne = bufferedReader.readLine()) != null) {
                contenu.append(ligne).append(System.lineSeparator());
            }

            System.out.println(contenu);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Écriture (BufferedWriter + FileWriter)​

  • Écriture simple d’un fichier texte. FileWriter ouvre le fichier et BufferedWriter regroupe les écritures pour être plus efficace.

  • FileWriter ouvre un fichier texte en écriture.

  • BufferedWriter ajoute un tampon pour écrire plus efficacement.

Exemple écriture​

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class EcritureFichierSimple {

    public static void main(String[] args) {
        String contenu = "Ligne 1" + System.lineSeparator()
                       + "Ligne 2" + System.lineSeparator()
                       + "Ligne 3";

        try (FileWriter fileWriter = new FileWriter("output.txt");
             BufferedWriter bufferedWriter = new BufferedWriter(fileWriter)) {

            bufferedWriter.write(contenu);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Try-with-resources (exemple complet)​

  • try-with-resources ferme automatiquement les fichiers à la fin du bloc, même en cas d’exception. L’exemple lit un fichier puis réécrit son contenu.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class LectureEcritureSimple {

    public static void main(String[] args) {
        StringBuilder contenu = new StringBuilder();

        try (FileReader fileReader = new FileReader("abc.txt");
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {

            String ligne;
            while ((ligne = bufferedReader.readLine()) != null) {
                contenu.append(ligne).append(System.lineSeparator());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        try (FileWriter fileWriter = new FileWriter("output.txt");
             BufferedWriter bufferedWriter = new BufferedWriter(fileWriter)) {

            bufferedWriter.write(contenu.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Mode append (ajouter à la fin)​

Utilise true pour ne pas écraser le fichier:

try (BufferedWriter writer = new BufferedWriter(new FileWriter("log.txt", true))) {
    writer.write("Nouvelle entrée" + System.lineSeparator());
} catch (IOException e) {
    e.printStackTrace();
}

Formats de données structurées

JSON (JavaScript Object Notation)​

JSON est le format le plus populaire pour échanger des données aujourd'hui.

Avantages​

  • Lisible par les humains
  • Indépendant du langage (compatible avec tous les langages)
  • Léger et facile à déboguer
  • Standard web (APIs REST)
  • Nombreuses bibliothèques disponibles

Bibliothèques Java populaires​

  • GSON (Google)
  • Jackson
  • JSON-B (Jakarta EE)

Exemple avec GSON​

1. Ajouter la dépendance GSON (dans Maven pom.xml) :

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

2. Code avec GSON :

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ExempleJSON {
    
    public static void main(String[] args) {
        // Créer un objet Gson avec formatage joli
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        
        // Créer des données
        Etudiant alice = new Etudiant("Dupont", "Alice");
        alice.ajouterNote(new Note(
            new Cours("420-C27", "Programmation II"),
            85, 100, 40
        ));
        
        // SÉRIALISATION : Objet -> JSON
        try (FileWriter writer = new FileWriter("etudiant.json")) {
            gson.toJson(alice, writer);
            System.out.println("Étudiant sauvegardé en JSON");
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // DÉSÉRIALISATION : JSON -> Objet
        try (FileReader reader = new FileReader("etudiant.json")) {
            Etudiant etudiantCharge = gson.fromJson(reader, Etudiant.class);
            System.out.println("Étudiant chargé depuis JSON :");
            System.out.println(etudiantCharge);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Fichier JSON généré (etudiant.json) :

{
  "nom": "Dupont",
  "prenom": "Alice",
  "notes": [
    {
      "cours": {
        "code": "420-C27",
        "nom": "Programmation II"
      },
      "note": 85.0,
      "total": 100.0,
      "valeur": 40.0
    }
  ]
}

Note importante : Avec JSON, les classes n'ont pas besoin d'implémenter Serializable.

XML (eXtensible Markup Language)​

XML était le standard avant JSON. Il est encore utilisé dans certains systèmes legacy et configurations.

Avantages​

  • Lisible par les humains
  • Support natif de la validation (XSD)
  • Bon pour les documents structurés complexes

Inconvénients​

  • Très verbeux (fichiers volumineux)
  • Plus complexe à parser que JSON
  • Moins populaire aujourd'hui

Exemple simple avec JAXB​

import javax.xml.bind.*;
import java.io.*;

@XmlRootElement
class Personne {
    private String nom;
    private int age;
    
    // Constructeurs, getters, setters...
}

public class ExempleXML {
    public static void main(String[] args) throws JAXBException {
        Personne p = new Personne("Alice", 25);
        
        // Sérialisation
        JAXBContext context = JAXBContext.newInstance(Personne.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(p, new File("personne.xml"));
        
        // Désérialisation
        Unmarshaller unmarshaller = context.createUnmarshaller();
        Personne p2 = (Personne) unmarshaller.unmarshal(new File("personne.xml"));
    }
}

Fichier XML généré :

<?xml version="1.0" encoding="UTF-8"?>
<personne>
    <nom>Alice</nom>
    <age>25</age>
</personne>

CSV (Comma-Separated Values)​

CSV est idéal pour les données tabulaires (listes d'objets simples).

Avantages​

  • Très simple et léger
  • Compatible avec Excel et tableurs
  • Facile à lire et modifier manuellement

Inconvénients​

  • Ne supporte pas les structures complexes
  • Limité aux données plates (pas d'imbrication)
  • Pas de types de données (tout est texte)

Exemple simple​

import java.io.*;
import java.util.ArrayList;
import java.util.List;

class Etudiant {
    String nom;
    String prenom;
    double moyenne;
    
    public Etudiant(String nom, String prenom, double moyenne) {
        this.nom = nom;
        this.prenom = prenom;
        this.moyenne = moyenne;
    }
    
    public String toCSV() {
        return nom + "," + prenom + "," + moyenne;
    }
    
    public static Etudiant fromCSV(String ligne) {
        String[] parts = ligne.split(",");
        return new Etudiant(parts[0], parts[1], Double.parseDouble(parts[2]));
    }
}

public class ExempleCSV {
    public static void main(String[] args) {
        List<Etudiant> etudiants = new ArrayList<>();
        etudiants.add(new Etudiant("Tremblay", "Marie", 85.5));
        etudiants.add(new Etudiant("Dupont", "Jean", 78.0));
        
        // Écriture CSV
        try (PrintWriter writer = new PrintWriter("etudiants.csv")) {
            writer.println("nom,prenom,moyenne"); // En-tête
            for (Etudiant e : etudiants) {
                writer.println(e.toCSV());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        
        // Lecture CSV
        try (BufferedReader reader = new BufferedReader(new FileReader("etudiants.csv"))) {
            reader.readLine(); // Ignorer l'en-tête
            String ligne;
            while ((ligne = reader.readLine()) != null) {
                Etudiant e = Etudiant.fromCSV(ligne);
                System.out.println(e.prenom + " " + e.nom + " : " + e.moyenne);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Fichier CSV généré :

nom,prenom,moyenne
Tremblay,Marie,85.5
Dupont,Jean,78.0